#include "client_wrapper.h"
#include <QDebug>
#include <QFileInfo>

ClientWrapper::ClientWrapper(QObject *parent)
    : QObject(parent), m_connected(false), m_serverPort(0), m_isLoggedIn(false)
{
    // 连接GuiSignaler的信号到ClientWrapper的信号
    // 这样ClientWrapper就可以在收到GUI桥接的消息时转发给GUI
    connect(GuiSignaler::instance(), &GuiSignaler::loginResultReceived,
            this, &ClientWrapper::onLoginResponse, Qt::QueuedConnection);

    connect(GuiSignaler::instance(), &GuiSignaler::registrationResultCb,
            this, &ClientWrapper::handleRegistrationCallback, Qt::QueuedConnection);

    connect(GuiSignaler::instance(), &GuiSignaler::fileListUpdated,
            this, &ClientWrapper::fileListUpdated, Qt::QueuedConnection);

    connect(GuiSignaler::instance(), &GuiSignaler::logMessageReceived,
            this, &ClientWrapper::logMessage, Qt::QueuedConnection);

    connect(GuiSignaler::instance(), &GuiSignaler::transferProgressUpdated,
            this, &ClientWrapper::transferProgress, Qt::QueuedConnection);

    connect(GuiSignaler::instance(), &GuiSignaler::transferCompleted,
            this, &ClientWrapper::transferCompleted, Qt::QueuedConnection);

    // Connect the new delete result callback signal from GuiSignaler
    connect(GuiSignaler::instance(), &GuiSignaler::deleteResultCb,
            this, &ClientWrapper::handleDeleteFileResultCallback, Qt::QueuedConnection);
}

ClientWrapper::~ClientWrapper()
{
    // 断开连接
    if (m_connected)
    {
        logout();
        sfts_client_disconnect();
    }
}

bool ClientWrapper::connectToServer(const QString &serverIP, int serverPort)
{
    if (m_connected)
    {
        // 如果已连接，先断开
        sfts_client_disconnect();
        m_connected = false;
        emit connectionStatusChanged(false);
    }

    int result = sfts_client_init_connection(serverIP.toStdString().c_str(), serverPort);
    if (result == 0)
    {
        m_serverIP = serverIP;
        m_serverPort = serverPort;
        m_connected = true;
        emit connectionStatusChanged(true);
        emit logMessage(tr("已连接到服务器 %1:%2").arg(serverIP).arg(serverPort), false);
        return true;
    }
    else
    {
        emit logMessage(tr("连接服务器 %1:%2 失败").arg(serverIP).arg(serverPort), true);
        return false;
    }
}

bool ClientWrapper::login(const QString &username, const QString &password)
{
    if (!m_connected)
    {
        emit logMessage(tr("未连接到服务器，无法登录"), true);
        return false;
    }

    int result = sfts_client_login(username.toStdString().c_str(), password.toStdString().c_str());
    if (result == 0)
    {
        // 登录请求已发送，实际结果会通过回调通知
        return true;
    }
    else
    {
        emit logMessage(tr("登录请求发送失败"), true);
        return false;
    }
}

bool ClientWrapper::registerUser(const QString &username, const QString &password)
{
    if (!m_connected)
    {
        emit logMessage(tr("未连接到服务器，无法注册"), true);
        emit registerResult(false, tr("未连接到服务器，无法注册"));
        return false;
    }

    int result = sfts_client_register(username.toStdString().c_str(), password.toStdString().c_str());
    if (result == 0)
    {
        emit logMessage(tr("注册请求已发送"), false);
        return true;
    }
    else
    {
        QString errorMsg = tr("注册请求发送失败 (错误码: %1)").arg(result);
        emit logMessage(errorMsg, true);
        emit registerResult(false, errorMsg);
        return false;
    }
}

bool ClientWrapper::requestFileList(const QString &path)
{
    if (!m_connected || !m_isLoggedIn)
    {
        emit logMessage(tr("未登录或未连接，无法获取文件列表"), true);
        return false;
    }

    int result = sfts_client_request_file_list(path.toStdString().c_str());
    if (result == 0)
    {
        emit logMessage(tr("正在获取目录 %1 的文件列表...").arg(path), false);
        return true;
    }
    else
    {
        emit logMessage(tr("获取文件列表请求失败"), true);
        return false;
    }
}

bool ClientWrapper::uploadFile(const QString &localPath, const QString &remotePath)
{
    if (!m_connected || !m_isLoggedIn)
    {
        emit logMessage(tr("未登录或未连接，无法上传文件"), true);
        return false;
    }

    QFileInfo fileInfo(localPath);
    if (!fileInfo.exists() || !fileInfo.isFile())
    {
        emit logMessage(tr("本地文件不存在或不是文件: %1").arg(localPath), true);
        return false;
    }

    int result = sfts_client_upload_file(localPath.toStdString().c_str(),
                                         remotePath.toStdString().c_str());
    if (result == 0)
    {
        emit logMessage(tr("开始上传文件 %1 到 %2").arg(localPath).arg(remotePath), false);
        return true;
    }
    else
    {
        emit logMessage(tr("上传文件请求失败"), true);
        return false;
    }
}

bool ClientWrapper::downloadFile(const QString &remotePath, const QString &localPath)
{
    if (!m_connected || !m_isLoggedIn)
    {
        emit logMessage(tr("未登录或未连接，无法下载文件"), true);
        return false;
    }

    int result = sfts_client_download_file(remotePath.toStdString().c_str(),
                                           localPath.toStdString().c_str());
    if (result == 0)
    {
        emit logMessage(tr("开始下载文件 %1 到 %2").arg(remotePath).arg(localPath), false);
        return true;
    }
    else
    {
        emit logMessage(tr("下载文件请求失败"), true);
        return false;
    }
}

bool ClientWrapper::deleteFile(const QString &remotePath)
{
    if (!m_connected || !m_isLoggedIn)
    {
        QString errorMsg = tr("未登录或未连接，无法删除文件");
        emit logMessage(errorMsg, true);
        emit deleteFileResult(false, remotePath, errorMsg);
        return false;
    }

    int result = sfts_client_delete_file(remotePath.toStdString().c_str());
    if (result == 0)
    {
        emit logMessage(tr("文件删除请求已发送: %1").arg(remotePath), false);
        return true;
    }
    else
    {
        QString errorMsg = tr("删除文件 '%1' 请求发送失败 (错误码: %2)").arg(remotePath).arg(result);
        emit logMessage(errorMsg, true);
        emit deleteFileResult(false, remotePath, errorMsg);
        return false;
    }
}

bool ClientWrapper::cancelTransfer()
{
    if (!m_connected)
    {
        emit logMessage(tr("未连接到服务器，无法取消传输"), true);
        return false;
    }

    int result = sfts_client_cancel_transfer();
    if (result == 0)
    {
        emit logMessage(tr("传输取消请求已发送"), false);
        return true;
    }
    else
    {
        emit logMessage(tr("取消传输请求失败"), true);
        return false;
    }
}

bool ClientWrapper::changeDirectory(const QString &directoryPath)
{
    if (!m_connected || !m_isLoggedIn)
    {
        emit logMessage(tr("未登录或未连接，无法切换目录"), true);
        return false;
    }

    int result = sfts_client_change_directory(directoryPath.toStdString().c_str());
    if (result == 0)
    {
        emit logMessage(tr("正在切换到目录: %1").arg(directoryPath), false);
        return true;
    }
    else
    {
        emit logMessage(tr("切换目录失败"), true);
        return false;
    }
}

bool ClientWrapper::logout()
{
    if (!m_connected)
    {
        emit logMessage(tr("未连接到服务器，无需退出登录"), true);
        return false;
    }

    int result = sfts_client_logout();
    if (result == 0)
    {
        m_isLoggedIn = false;
        m_currentUser.clear();
        emit logMessage(tr("已退出登录"), false);
        return true;
    }
    else
    {
        emit logMessage(tr("退出登录失败"), true);
        return false;
    }
}

void ClientWrapper::onLoginResponse(bool success, const QString &messageOrUsername)
{
    if (success)
    {
        m_isLoggedIn = true;
        m_currentUser = messageOrUsername; // Store the actual username
    }
    else
    {
        m_isLoggedIn = false;
        m_currentUser.clear();
    }
    emit loginResult(success, messageOrUsername); // Forward the signal for LoginWindow etc.
}

void ClientWrapper::handleRegistrationCallback(bool success, const QString &message)
{
    emit registerResult(success, message);
}

void ClientWrapper::handleDeleteFileResultCallback(bool success, const QString &filename, const QString &message)
{
    emit deleteFileResult(success, filename, message);
}